eligible

This is never set. Please don't add any fields that are invalid.

To follow up, this can simply be set in newBestState from node.finalState.

This is wrong. It would calculate the stake diff for the block after the one being disconnected. You can just use the data that is already in node.sbits though since it's about to be disconnected and hence is the next stake difficulty as compared to the previous block for which the new state represents.

No need to calculate this when creating a chain state for the genesis block. The next stake difficulty is already well known for the block after the genesis block. In particular, it's b.chainParams.MinimumStakeDiff.

You should use b.calcNextRequiredStakeDifficulty(node) instead to be sure you're calculating it for the correct node. Otherwise, the tip isn't updated yet, so you'll be off by one.

You should use b.calcNextRequiredStakeDifficulty(tip) instead to be sure you're calculating it for the correct node.

This will crash if called on a new chain with the genesis block, because it has not parent.

Needs to be:

   prevHash := zeroHash
    if node.parent != nil {
        prevHash = &node.parent.hash
    }
    return &BestState{
        ...
        PrevHash: *prevHash,
        ...
    }

This could easily crash with node.stakeNode not being loaded since the field is dynamically loaded. You need to make sure that you call fetchStakeNode prior to invoking newBestState with these changes.

In the case of connectBlock and disconnectBlock, there are already calls to load the stake nodes, but they are after the calls to newBestState, so the loading code should be moved above the blocks of code which deal with setting the best state.

For example:

diff --git a/blockchain/chain.go b/blockchain/chain.go
index 4856d241..3bc0c86a 100644
--- a/blockchain/chain.go
+++ b/blockchain/chain.go
@@ -747,6 +747,15 @@ func (b *BlockChain) connectBlock(node *blockNode, block, parent *dcrutil.Block,
                return err
        }

+       // Get the stake node for this node, filling in any data that
+       // may have yet to have been filled in.  In all cases this
+       // should simply give a pointer to data already prepared, but
+       // run this anyway to be safe.
+       stakeNode, err := b.fetchStakeNode(node)
+       if err != nil {
+               return err
+       }
+
        // Generate a new best state snapshot that will be used to update the
        // database and later memory if all database updates are successful.
        b.stateLock.RLock()
@@ -765,15 +774,6 @@ func (b *BlockChain) connectBlock(node *blockNode, block, parent *dcrutil.Block,
        state := newBestState(node, blockSize, numTxns, curTotalTxns+numTxns,
                node.CalcPastMedianTime(), curTotalSubsidy+subsidy)

-       // Get the stake node for this node, filling in any data that
-       // may have yet to have been filled in.  In all cases this
-       // should simply give a pointer to data already prepared, but
-       // run this anyway to be safe.
-       stakeNode, err := b.fetchStakeNode(node)
-       if err != nil {
-               return err
-       }
-
        // Atomically insert info into the database.
        err = b.db.Update(func(dbTx database.Tx) error {
                // Update best block state.

In the case of the init path, you'll need to load the stake nodes.

Calculate

This is incorrect. Please see my previous comments about the need to call fetchStakeNode and from where.